home *** CD-ROM | disk | FTP | other *** search
/ The Complete Utilities To…ka 501 Killer Utilities! / 501 Killer Utilities! (Macworld July 1995).cdr / Programming / OutOfPhase1.1 Source / OutOfPhase Folder / NonlinearProcSpec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-08  |  12.8 KB  |  512 lines  |  [TEXT/KAHL]
  1. /* NonlinearProcSpec.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "NonlinearProcSpec.h"
  31. #include "Memory.h"
  32. #include "LFOListSpecifier.h"
  33. #include "Envelope.h"
  34.  
  35.  
  36. struct NonlinProcSpecRec
  37.     {
  38.         /* what kind of effect */
  39.         NLProcWaveType            WaveType;
  40.         union
  41.             {
  42.                 struct WaveTableObjectRec*            DataWaveTable;
  43.                 struct AlgoWaveTableObjectRec*    AlgoWaveTable;
  44.             } u;
  45.  
  46.         /* these controls only apply to the track effect, not the oscillator effect */
  47.         float                                InputScaling;
  48.         float                                InputAccent1;
  49.         float                                InputAccent2;
  50.         float                                InputAccent3;
  51.         float                                InputAccent4;
  52.         float                                OutputScaling;
  53.         float                                OutputAccent1;
  54.         float                                OutputAccent2;
  55.         float                                OutputAccent3;
  56.         float                                OutputAccent4;
  57.         float                                WaveTableIndex;
  58.         float                                IndexAccent1;
  59.         float                                IndexAccent2;
  60.         float                                IndexAccent3;
  61.         float                                IndexAccent4;
  62.  
  63.         /* these controls apply only to the oscillator effect, not the track effect */
  64.         EnvelopeRec*                InputEnvelope;
  65.         EnvelopeRec*                OutputEvelope;
  66.         EnvelopeRec*                IndexEnvelope;
  67.         LFOListSpecRec*            InputLFO;
  68.         LFOListSpecRec*            OutputLFO;
  69.         LFOListSpecRec*            IndexLFO;
  70.     };
  71.  
  72.  
  73. /* create a new nonlinear processor specifier */
  74. NonlinProcSpecRec*    NewNonlinProcSpecDataWave(struct WaveTableObjectRec* Wave)
  75.     {
  76.         NonlinProcSpecRec*    NLProc;
  77.  
  78.         CheckPtrExistence(Wave);
  79.         NLProc = (NonlinProcSpecRec*)AllocPtrCanFail(sizeof(NonlinProcSpecRec),
  80.             "NonlinProcSpecRec");
  81.         if (NLProc == NIL)
  82.             {
  83.              FailurePoint1:
  84.                 return NIL;
  85.             }
  86.         NLProc->InputEnvelope = NewEnvelope();
  87.         if (NLProc->InputEnvelope == NIL)
  88.             {
  89.              FailurePoint2:
  90.                 ReleasePtr((char*)NLProc);
  91.                 goto FailurePoint1;
  92.             }
  93.         NLProc->OutputEvelope = NewEnvelope();
  94.         if (NLProc->OutputEvelope == NIL)
  95.             {
  96.              FailurePoint3:
  97.                 DisposeEnvelope(NLProc->InputEnvelope);
  98.                 goto FailurePoint2;
  99.             }
  100.         NLProc->IndexEnvelope = NewEnvelope();
  101.         if (NLProc->IndexEnvelope == NIL)
  102.             {
  103.              FailurePoint4:
  104.                 DisposeEnvelope(NLProc->OutputEvelope);
  105.                 goto FailurePoint3;
  106.             }
  107.         NLProc->InputLFO = NewLFOListSpecifier();
  108.         if (NLProc->InputLFO == NIL)
  109.             {
  110.              FailurePoint5:
  111.                 DisposeEnvelope(NLProc->IndexEnvelope);
  112.                 goto FailurePoint4;
  113.             }
  114.         NLProc->OutputLFO = NewLFOListSpecifier();
  115.         if (NLProc->OutputLFO == NIL)
  116.             {
  117.              FailurePoint6:
  118.                 DisposeLFOListSpecifier(NLProc->InputLFO);
  119.                 goto FailurePoint5;
  120.             }
  121.         NLProc->IndexLFO = NewLFOListSpecifier();
  122.         if (NLProc->IndexLFO == NIL)
  123.             {
  124.              FailurePoint7:
  125.                 DisposeLFOListSpecifier(NLProc->OutputLFO);
  126.                 goto FailurePoint6;
  127.             }
  128.         NLProc->WaveType = eNLDataWaveTable;
  129.         NLProc->u.DataWaveTable = Wave;
  130.         NLProc->InputScaling = 1;
  131.         NLProc->InputAccent1 = 0;
  132.         NLProc->InputAccent2 = 0;
  133.         NLProc->InputAccent3 = 0;
  134.         NLProc->InputAccent4 = 0;
  135.         NLProc->OutputScaling = 1;
  136.         NLProc->OutputAccent1 = 0;
  137.         NLProc->OutputAccent2 = 0;
  138.         NLProc->OutputAccent3 = 0;
  139.         NLProc->OutputAccent4 = 0;
  140.         NLProc->WaveTableIndex = 0;
  141.         NLProc->IndexAccent1 = 0;
  142.         NLProc->IndexAccent2 = 0;
  143.         NLProc->IndexAccent3 = 0;
  144.         NLProc->IndexAccent4 = 0;
  145.         return NLProc;
  146.     }
  147.  
  148.  
  149. /* create a new nonlinear processor specifier */
  150. NonlinProcSpecRec*    NewNonlinProcSpecAlgoWave(struct AlgoWaveTableObjectRec* Wave)
  151.     {
  152.         NonlinProcSpecRec*    NLProc;
  153.  
  154.         CheckPtrExistence(Wave);
  155.         NLProc = (NonlinProcSpecRec*)AllocPtrCanFail(sizeof(NonlinProcSpecRec),
  156.             "NonlinProcSpecRec");
  157.         if (NLProc == NIL)
  158.             {
  159.              FailurePoint1:
  160.                 return NIL;
  161.             }
  162.         NLProc->InputEnvelope = NewEnvelope();
  163.         if (NLProc->InputEnvelope == NIL)
  164.             {
  165.              FailurePoint2:
  166.                 ReleasePtr((char*)NLProc);
  167.                 goto FailurePoint1;
  168.             }
  169.         NLProc->OutputEvelope = NewEnvelope();
  170.         if (NLProc->OutputEvelope == NIL)
  171.             {
  172.              FailurePoint3:
  173.                 DisposeEnvelope(NLProc->InputEnvelope);
  174.                 goto FailurePoint2;
  175.             }
  176.         NLProc->IndexEnvelope = NewEnvelope();
  177.         if (NLProc->IndexEnvelope == NIL)
  178.             {
  179.              FailurePoint4:
  180.                 DisposeEnvelope(NLProc->OutputEvelope);
  181.                 goto FailurePoint3;
  182.             }
  183.         NLProc->InputLFO = NewLFOListSpecifier();
  184.         if (NLProc->InputLFO == NIL)
  185.             {
  186.              FailurePoint5:
  187.                 DisposeEnvelope(NLProc->IndexEnvelope);
  188.                 goto FailurePoint4;
  189.             }
  190.         NLProc->OutputLFO = NewLFOListSpecifier();
  191.         if (NLProc->OutputLFO == NIL)
  192.             {
  193.              FailurePoint6:
  194.                 DisposeLFOListSpecifier(NLProc->InputLFO);
  195.                 goto FailurePoint5;
  196.             }
  197.         NLProc->IndexLFO = NewLFOListSpecifier();
  198.         if (NLProc->IndexLFO == NIL)
  199.             {
  200.              FailurePoint7:
  201.                 DisposeLFOListSpecifier(NLProc->OutputLFO);
  202.                 goto FailurePoint6;
  203.             }
  204.         NLProc->WaveType = eNLAlgoWaveTable;
  205.         NLProc->u.AlgoWaveTable = Wave;
  206.         NLProc->InputScaling = 1;
  207.         NLProc->InputAccent1 = 0;
  208.         NLProc->InputAccent2 = 0;
  209.         NLProc->InputAccent3 = 0;
  210.         NLProc->InputAccent4 = 0;
  211.         NLProc->OutputScaling = 1;
  212.         NLProc->OutputAccent1 = 0;
  213.         NLProc->OutputAccent2 = 0;
  214.         NLProc->OutputAccent3 = 0;
  215.         NLProc->OutputAccent4 = 0;
  216.         return NLProc;
  217.     }
  218.  
  219.  
  220. /* dispose of the nonlinear processor specifier */
  221. void                                DisposeNonlinProcSpec(NonlinProcSpecRec* NLProc)
  222.     {
  223.         CheckPtrExistence(NLProc);
  224.         DisposeEnvelope(NLProc->InputEnvelope);
  225.         DisposeEnvelope(NLProc->OutputEvelope);
  226.         DisposeEnvelope(NLProc->IndexEnvelope);
  227.         DisposeLFOListSpecifier(NLProc->InputLFO);
  228.         DisposeLFOListSpecifier(NLProc->OutputLFO);
  229.         DisposeLFOListSpecifier(NLProc->IndexLFO);
  230.         ReleasePtr((char*)NLProc);
  231.     }
  232.  
  233.  
  234. void                                PutNLProcInputScaling(NonlinProcSpecRec* NLProc, float InputScaling)
  235.     {
  236.         CheckPtrExistence(NLProc);
  237.         NLProc->InputScaling = InputScaling;
  238.     }
  239.  
  240.  
  241. void                                PutNLProcInputAccent1(NonlinProcSpecRec* NLProc, float InputAccent1)
  242.     {
  243.         CheckPtrExistence(NLProc);
  244.         NLProc->InputAccent1 = InputAccent1;
  245.     }
  246.  
  247.  
  248. void                                PutNLProcInputAccent2(NonlinProcSpecRec* NLProc, float InputAccent2)
  249.     {
  250.         CheckPtrExistence(NLProc);
  251.         NLProc->InputAccent2 = InputAccent2;
  252.     }
  253.  
  254.  
  255. void                                PutNLProcInputAccent3(NonlinProcSpecRec* NLProc, float InputAccent3)
  256.     {
  257.         CheckPtrExistence(NLProc);
  258.         NLProc->InputAccent3 = InputAccent3;
  259.     }
  260.  
  261.  
  262. void                                PutNLProcInputAccent4(NonlinProcSpecRec* NLProc, float InputAccent4)
  263.     {
  264.         CheckPtrExistence(NLProc);
  265.         NLProc->InputAccent4 = InputAccent4;
  266.     }
  267.  
  268.  
  269. void                                PutNLProcOutputScaling(NonlinProcSpecRec* NLProc, float OutputScaling)
  270.     {
  271.         CheckPtrExistence(NLProc);
  272.         NLProc->OutputScaling = OutputScaling;
  273.     }
  274.  
  275.  
  276. void                                PutNLProcOutputAccent1(NonlinProcSpecRec* NLProc, float OutputAccent1)
  277.     {
  278.         CheckPtrExistence(NLProc);
  279.         NLProc->OutputAccent1 = OutputAccent1;
  280.     }
  281.  
  282.  
  283. void                                PutNLProcOutputAccent2(NonlinProcSpecRec* NLProc, float OutputAccent2)
  284.     {
  285.         CheckPtrExistence(NLProc);
  286.         NLProc->OutputAccent2 = OutputAccent2;
  287.     }
  288.  
  289.  
  290. void                                PutNLProcOutputAccent3(NonlinProcSpecRec* NLProc, float OutputAccent3)
  291.     {
  292.         CheckPtrExistence(NLProc);
  293.         NLProc->OutputAccent3 = OutputAccent3;
  294.     }
  295.  
  296.  
  297. void                                PutNLProcOutputAccent4(NonlinProcSpecRec* NLProc, float OutputAccent4)
  298.     {
  299.         CheckPtrExistence(NLProc);
  300.         NLProc->OutputAccent4 = OutputAccent4;
  301.     }
  302.  
  303.  
  304. void                                PutNLProcWaveTableIndex(NonlinProcSpecRec* NLProc, float WaveTableIndex)
  305.     {
  306.         CheckPtrExistence(NLProc);
  307.         NLProc->WaveTableIndex = WaveTableIndex;
  308.     }
  309.  
  310.  
  311. void                                PutNLProcIndexAccent1(NonlinProcSpecRec* NLProc, float IndexAccent1)
  312.     {
  313.         CheckPtrExistence(NLProc);
  314.         NLProc->IndexAccent1 = IndexAccent1;
  315.     }
  316.  
  317.  
  318. void                                PutNLProcIndexAccent2(NonlinProcSpecRec* NLProc, float IndexAccent2)
  319.     {
  320.         CheckPtrExistence(NLProc);
  321.         NLProc->IndexAccent2 = IndexAccent2;
  322.     }
  323.  
  324.  
  325. void                                PutNLProcIndexAccent3(NonlinProcSpecRec* NLProc, float IndexAccent3)
  326.     {
  327.         CheckPtrExistence(NLProc);
  328.         NLProc->IndexAccent3 = IndexAccent3;
  329.     }
  330.  
  331.  
  332. void                                PutNLProcIndexAccent4(NonlinProcSpecRec* NLProc, float IndexAccent4)
  333.     {
  334.         CheckPtrExistence(NLProc);
  335.         NLProc->IndexAccent4 = IndexAccent4;
  336.     }
  337.  
  338.  
  339. float                                GetNLProcInputScaling(NonlinProcSpecRec* NLProc)
  340.     {
  341.         CheckPtrExistence(NLProc);
  342.         return NLProc->InputScaling;
  343.     }
  344.  
  345.  
  346. float                                GetNLProcInputAccent1(NonlinProcSpecRec* NLProc)
  347.     {
  348.         CheckPtrExistence(NLProc);
  349.         return NLProc->InputAccent1;
  350.     }
  351.  
  352.  
  353. float                                GetNLProcInputAccent2(NonlinProcSpecRec* NLProc)
  354.     {
  355.         CheckPtrExistence(NLProc);
  356.         return NLProc->InputAccent2;
  357.     }
  358.  
  359.  
  360. float                                GetNLProcInputAccent3(NonlinProcSpecRec* NLProc)
  361.     {
  362.         CheckPtrExistence(NLProc);
  363.         return NLProc->InputAccent3;
  364.     }
  365.  
  366.  
  367. float                                GetNLProcInputAccent4(NonlinProcSpecRec* NLProc)
  368.     {
  369.         CheckPtrExistence(NLProc);
  370.         return NLProc->InputAccent4;
  371.     }
  372.  
  373.  
  374. float                                GetNLProcOutputScaling(NonlinProcSpecRec* NLProc)
  375.     {
  376.         CheckPtrExistence(NLProc);
  377.         return NLProc->OutputScaling;
  378.     }
  379.  
  380.  
  381. float                                GetNLProcOutputAccent1(NonlinProcSpecRec* NLProc)
  382.     {
  383.         CheckPtrExistence(NLProc);
  384.         return NLProc->OutputAccent1;
  385.     }
  386.  
  387.  
  388. float                                GetNLProcOutputAccent2(NonlinProcSpecRec* NLProc)
  389.     {
  390.         CheckPtrExistence(NLProc);
  391.         return NLProc->OutputAccent2;
  392.     }
  393.  
  394.  
  395. float                                GetNLProcOutputAccent3(NonlinProcSpecRec* NLProc)
  396.     {
  397.         CheckPtrExistence(NLProc);
  398.         return NLProc->OutputAccent3;
  399.     }
  400.  
  401.  
  402. float                                GetNLProcOutputAccent4(NonlinProcSpecRec* NLProc)
  403.     {
  404.         CheckPtrExistence(NLProc);
  405.         return NLProc->OutputAccent4;
  406.     }
  407.  
  408.  
  409. float                                GetNLProcWaveTableIndex(NonlinProcSpecRec* NLProc)
  410.     {
  411.         CheckPtrExistence(NLProc);
  412.         return NLProc->WaveTableIndex;
  413.     }
  414.  
  415.  
  416. float                                GetNLProcIndexAccent1(NonlinProcSpecRec* NLProc)
  417.     {
  418.         CheckPtrExistence(NLProc);
  419.         return NLProc->IndexAccent1;
  420.     }
  421.  
  422.  
  423. float                                GetNLProcIndexAccent2(NonlinProcSpecRec* NLProc)
  424.     {
  425.         CheckPtrExistence(NLProc);
  426.         return NLProc->IndexAccent2;
  427.     }
  428.  
  429.  
  430. float                                GetNLProcIndexAccent3(NonlinProcSpecRec* NLProc)
  431.     {
  432.         CheckPtrExistence(NLProc);
  433.         return NLProc->IndexAccent3;
  434.     }
  435.  
  436.  
  437. float                                GetNLProcIndexAccent4(NonlinProcSpecRec* NLProc)
  438.     {
  439.         CheckPtrExistence(NLProc);
  440.         return NLProc->IndexAccent4;
  441.     }
  442.  
  443.  
  444. /* get the wave type */
  445. NLProcWaveType            GetNLProcSpecWaveType(NonlinProcSpecRec* NLProc)
  446.     {
  447.         CheckPtrExistence(NLProc);
  448.         return NLProc->WaveType;
  449.     }
  450.  
  451.  
  452. /* get the algorithmic wave table from the nl proc */
  453. struct AlgoWaveTableObjectRec*    GetNLProcSpecAlgoWaveTable(NonlinProcSpecRec* NLProc)
  454.     {
  455.         CheckPtrExistence(NLProc);
  456.         ERROR(eNLAlgoWaveTable != GetNLProcSpecWaveType(NLProc),
  457.             PRERR(ForceAbort,"GetNLProcSpecAlgoWaveTable:  not an algorithmic wave table"));
  458.         return NLProc->u.AlgoWaveTable;
  459.     }
  460.  
  461.  
  462. /* get the data wave table from the nl proc */
  463. struct WaveTableObjectRec*    GetNLProcSpecDataWaveTable(NonlinProcSpecRec* NLProc)
  464.     {
  465.         CheckPtrExistence(NLProc);
  466.         ERROR(eNLDataWaveTable != GetNLProcSpecWaveType(NLProc),
  467.             PRERR(ForceAbort,"GetNLProcSpecDataWaveTable:  not a data wave table"));
  468.         return NLProc->u.DataWaveTable;
  469.     }
  470.  
  471.  
  472. struct EnvelopeRec*    GetNLProcInputEnvelope(NonlinProcSpecRec* NLProc)
  473.     {
  474.         CheckPtrExistence(NLProc);
  475.         return NLProc->InputEnvelope;
  476.     }
  477.  
  478.  
  479. struct EnvelopeRec*    GetNLProcOutputEnvelope(NonlinProcSpecRec* NLProc)
  480.     {
  481.         CheckPtrExistence(NLProc);
  482.         return NLProc->OutputEvelope;
  483.     }
  484.  
  485.  
  486. struct EnvelopeRec*    GetNLProcIndexEnvelope(NonlinProcSpecRec* NLProc)
  487.     {
  488.         CheckPtrExistence(NLProc);
  489.         return NLProc->IndexEnvelope;
  490.     }
  491.  
  492.  
  493. struct LFOListSpecRec*    GetNLProcInputLFO(NonlinProcSpecRec* NLProc)
  494.     {
  495.         CheckPtrExistence(NLProc);
  496.         return NLProc->InputLFO;
  497.     }
  498.  
  499.  
  500. struct LFOListSpecRec*    GetNLProcOutputLFO(NonlinProcSpecRec* NLProc)
  501.     {
  502.         CheckPtrExistence(NLProc);
  503.         return NLProc->OutputLFO;
  504.     }
  505.  
  506.  
  507. struct LFOListSpecRec*    GetNLProcIndexLFO(NonlinProcSpecRec* NLProc)
  508.     {
  509.         CheckPtrExistence(NLProc);
  510.         return NLProc->IndexLFO;
  511.     }
  512.